Scalability is the capability of a computer application to handle a growing amount of work, or its potential to be enlarged in order to accommodate that growth. One way of scaling applications is by distributing application components across multiple computing devices (hosts/machines) and making these available remotely as microservices. The application can then use these microservices via a protocol such as REST/HTTP or other protocol to provide their functionality and as such spread the load to other entities to achieve scaling.
Existing scaling techniques require that the microservices of an application be designated and configured prior to the application's launch. However, applications often contain many components and it is not always clear in advance which components should be scaled. This is in part because the application load on the different components of the application depends on how the application will actually be used, which is both unknown and variable over time. It is thus often not known in advance which component should be implemented as microservices. Nor is implementing all components in the system as microservices appropriate because the remote nature of the microservices adds a significant protocol overhead cost. Components that do not put a significant load on the system are more efficiently implemented locally than as microservices to avoid the overhead cost. Thus, it is generally desirable to only implement microservices for components in circumstances where the load reduction benefit of doing so outweighs the protocol overhead cost. However, since the load on the various components of the application is unknown in advance and variable over time, people have had to make subjective guesses about which components should be scaled. The result is that running applications use microservices inefficiently. Significant additional engineering time and efforts and application disruptions are required to refactor components as microservices and vice versa. This time, effort, and disruption make it impractical to refactor components generally and infeasible to do so based on changing load conditions over time.